#ifndef __GAMELOGIC_H_
#define __GAMELOGIC_H_

#include "Common.h"
#include "String.h"
#include "Resource.h"
#include "Vector3.h"
#include "ChannelManager.h"
#include "ItemManager.h"
#include "Threading/AtomicCounter.h"
#include "GameDefine.h"
#include "GameStruct.h"
#include "Database/Field.h"
#include "json/json.h"

class  WorldPacket;
class  Effect;
class  CharPtr;
class  ItemPtr;
class  ChannelPtr;
class  Channel;
class  UserPtr;
class  EffectPtr;
class  TownPtr;
class 	MissionPtr;
struct CardModel;
struct MaJonMission;
struct center_battle_tag_;
typedef center_battle_tag_ CenterBattle;

struct _user_authentic_st_;
typedef _user_authentic_st_ UserAuthenticInfo;

struct stPlayerCreateCenterBattle;
struct stSignleEffortInfo;

//排行操作锁
#define WGS_ORDER_MUTEX_NAME order_inner_mutex
#define WGS_ORDER_MUTEX mutable boost::mutex WGS_ORDER_MUTEX_NAME;
#define WGS_ORDER_LOCK		boost::lock_guard<boost::mutex> wgsOrderMutexLock(WGS_ORDER_MUTEX_NAME);

// 网关方法操作锁
#define WGS_GATEWAY_MUTEX_NAME gateway_inner_mutex
#define WGS_GATEWAY_MUTEX mutable boost::mutex WGS_GATEWAY_MUTEX_NAME;
#define WGS_GATEWAY_LOCK		boost::lock_guard<boost::mutex> wgsGatewayMutexLock(WGS_GATEWAY_MUTEX_NAME);

#ifdef _USE_DEFAULT_GAME_LOGIC_MGR_
	class GameLogicManager : public Singleton<GameLogicManager>
#else
	class GameLogicManager
#endif
{
	WGS_ORDER_MUTEX
	WGS_GATEWAY_MUTEX
public:
	
	virtual ~GameLogicManager(){};
	virtual UserPtr CreateUser(const String &userName, const uint32 &platform_id);
	/** 为USER创建角色,若数据库里面有该USER绑定的角色则返回该角色 */
	virtual CharPtr CreateCreature(UserPtr & user, bool isCenter = true);
	// 获取用户根据PID和GZID
	virtual CharPtr GetCharptrByPidAndGzid(const uint32 & platform_id, const uint32 & gz_id);
	// 获取元宝
	virtual uint32 GetGoldMoney(CharPtr & chr);
	// 设置元宝
	virtual void SetGoldMoney(CharPtr & chr, const uint32 gMoney);
	// 获取当前日期时间
	virtual String GetCurDateTime(time_t t = 0);
	
	/** 获取当前日期
	*	返回UINT32 格式:"年月日",以便于判断
	*/
	virtual uint32 GetCurDate(uint32 now_time = 0);
	/** 获取当前时间
	*	返回UINT32 格式:"时分",以便于判断
	*/
	virtual uint32 GetCurTimer(void);
	
	// 获取指定的日期时间
	virtual String GetDateTime(tm *pTm);
	// 获取指定日期的秒数
	virtual time_t GetDateTimeSeconds(String &str);
	/**
	 * 判断日期是否相同
	 */
	bool IsSameDate(time_t t1, time_t t2 = 0);
	
	// 创建物品
	virtual ItemPtr CreateItem(CharPtr & container, const uint32 & model_id, const uint32 & num, bool bSendPacket = true);
	// 根据脚本号创建物品
	virtual ItemPtr CreateItemByScriptID(CharPtr & pChr, const uint32 & script_id);
	
	// 获取物品
	virtual ItemPtr GetItem(CharPtr & chr, const uint32 & model_id); 
	
	// 设置物品数量,如果没有当前物品,则自动增加新物品
	virtual bool SetItemNum(CharPtr & chr, const uint32 & model_id, const uint32 & num);
	// 增加物品数量
	virtual ItemPtr addItemNum(CharPtr & chr, const uint32 & model_id, const uint32 & addnum, bool bUpdate = true);
	// 增加兑换道具数量
	virtual bool addExchangeItemNum(CharPtr & chr, const uint32 & model_id, const uint32 & addnum, stGatewayExChangeInfo stGEC);
	// 得到某个模式ID的道具列表
	virtual bool getItemListByModelid(CharPtr & pChr, const uint32 & model_id, std::list<ItemPtr> * lstItems);
	// 减少物品数量
	virtual bool reduceItemNum(CharPtr & chr, const uint32 & model_id, const uint32 & rNum, bool bUpdate = true, bool isBlocked = false);
	// 减少兑换道具数量
	
	// 获取某物品数量
	virtual uint32 GetItemNum(CharPtr & chr, const uint32 & model_id);
	// 获取某物品数量
	virtual uint32 GetItemTotalNum(CharPtr & chr, const uint32 & model_id);
	
	// 增加冻结物品数量,返回最终数据
	virtual uint32 addCongealItemNum(CharPtr & chr, const uint32 & model_id, const uint32 & addnum);
	// 减少冻结物品数量
	virtual bool reduceCongealItemNum(CharPtr & chr, const uint32 & model_id, const uint32 & rNum);
	// 还原冻结物品数量 (rNum 为0 表示还原所有)
	virtual bool rebornCongealItemNum(CharPtr & chr, const uint32 & model_id, const uint32 & rNum = 0,bool bUpdate = false);
	// 设置冻结物品数量
	virtual bool setCongealItemNum(CharPtr & pChr, const uint32 & model_id, const uint32 & num = 0);
	// 获取冻结物品数量
	virtual uint32 getCogealItemNum(CharPtr & pChr, const uint32 & model_id);
	
	//得到银行资产
	virtual uint64 GetBankerNum(CharPtr & chr, const uint32 model_id);
	/**
	 * @函数功能 获取玩家资产总金额
	 * @参数 
	 *  @chr 角色
	 *	@model_id 模式ID 
	 */
	virtual uint64 GetAllNum(CharPtr & chr, const uint32 model_id);
	
	// 解除冻结物品的数量,返回最终数量
	virtual uint32 resetCogealItemNum(CharPtr & pChr, const uint32 & model_id, bool isUpdate = true);
	
	// 根据Socket类型,发送数据包
	virtual void 	SendPacket(ResourcePtr & socket, WorldPacket * newP);
	// 给玩家发送协议
	virtual void SendProtocolsToChr(CharPtr & pChr, WorldPacket * packet);
	virtual void SendProtocolsToChrByPidGzid(const uint32 & pid, const uint32 & gz_id, WorldPacket * packet);

	// 发送系统消息
	virtual bool SendSystemMessage(CharPtr & chr, const char* pStr, const uint8 & type = 2);
	//发送系统调试信息
	virtual bool SendSysDebugMessage(CharPtr & chr, const uint32 & cid, const String & szName);
	
	// 添加效果
	virtual EffectPtr AddEffect(ResourceProxy owner, 
						const uint32 & model_id, 
						const uint32 & begin_time,
						const uint32 & data1 = 0, 
						const uint32 & data2 = 0, 
						const uint32 & data3 = 0, 
						const uint32 & data4 = 0,
						const float & fdata1 = 0.0f,
						const float & fdata2 = 0.0f);
									
	virtual EffectPtr GetEffect(ResourceProxy owner, const uint32 & model_id);
	// 添加任务
	virtual MissionPtr AddMission(CharPtr &pChr, 
								const uint32 &model_id,
								const uint32 &start_time = 0,
								const uint32 &data1 = 0,
								const uint32 &data2 = 0,
								const uint32 &data3 = 0,
								const uint32 &data4 = 0
								);
	virtual MissionPtr GetMission(CharPtr &pChr, const uint32 & model_id);
	
	virtual bool 	SendAddItemMessage(CharPtr & chr, const uint32 & model_id, const uint32 & number, const String & szType);
	virtual bool 	SendReduceItemMessage(CharPtr & chr, const uint32 & model_id, const uint32 & number, const String & szType);
	/**
	 * @创建时间 2011-11-21
	 * @创建人 李志勇
	 * @函数作用 广播除某位置外的玩家（排除位置为0，表示发给所有人）
	 * @参数
	 * 	@packet 数据封包
	 * 	@vecChars 需要广播的玩家列表
	 *  @exceptSeat 要排除的玩家位置，从1开始
	 */
	virtual void Broadcast(WorldPacket &packet, std::vector<CharPtr> &vecChars, const uint8 exceptSeat = 0);
	
	//发送给所有在线玩家
	virtual void BroadcastToAllUsers(WorldPacket &packet);
	// 向某房间类型广播消息
	virtual void BroadcastEx(WorldPacket * pPacket, const uint32 & town_type = 0, const uint32 & gz_id = 0);
	// 向某房间ID广播数据
	virtual void BroadcastByTownID(WorldPacket * pPacket, const uint32 & handle, const uint32 & excSerial = 0);
	// 向某个分区广播数据
	virtual void BroadcastByGZID(WorldPacket * pPacket, const uint32 & gz_id);
	// 向某个代理商ID广播数据
	virtual void BroadcastByFromID(WorldPacket * pPacket, const uint32 & from_id, const uint8 & send_player_flag = 0);
	// 断开用户连接
	virtual bool DisconnectUserSocket(ResourcePtr & socket);
	// 屏蔽玩家昵称
	virtual bool FilterChars(String str, String &outStr);
	// 清除所有人的邮件
	virtual bool CleanAllMails();
	// 清除个人邮件
	virtual bool CleanUserMails(const uint32 userId);
	// 清楚个人过期邮件
	virtual bool CheckExpireMails(const uint32 & pid,const uint32 & gz_id);
	// 领取邮件附件
	virtual uint8 GetMailItems(CharPtr & pChr,const uint32 & mailId);
	// 领取全服邮件
	virtual uint8 GetAllServerMailItems(CharPtr & pChr,const uint32 & mailId);
	// 领取所有邮件附件
	virtual uint8 GetAllMailsItems(CharPtr & pChr);
	// 比较全部邮件已读
	virtual uint8 ReadAllMails(CharPtr & pChr);
	// 删除邮件
	virtual uint8 DeleteMail(CharPtr & pChr, const uint32 & mail_id);
	// 下发二级密码锁定消息
	virtual void Pwd2LockedMessage(UserPtr &pUser, const uint32 leftTime);
	// 下发乐码锁定消息
	virtual void LewdLockedMessage(UserPtr &pUser, const uint32 leftTime);
	// 下发登录欢迎消息
	virtual void LoginWellcomeMessage(UserPtr &pUser);
	// 兑换兑换卡
	virtual uint8 CkExchageTicket(CharPtr &pChr, String &ticket);
	// 广播消息
	virtual void WholeServerBroadcast(WorldPacket *pPacket, const uint32 gzId = 0);
	
	// 公告
	virtual void SendNotice(String &strMsg, const uint32 type = 1, const uint32 gzId = 0);
	// 发消息给某个玩家
	virtual void SendMsgToPlayer(const uint32 userId, String &strMsg, const uint32 type = 2);
	// 添加头衔, isInstant: 是否即时发奖
	virtual bool 	addCreatureTitle(CharPtr & pChr, EffectPtr & pEffect, bool isInstant = true);
	// 头衔奖励
	virtual void 	SendTitleMessage(CharPtr & pChr, const String & szName, const uint32 & itmodel, const uint32 & itnum);
	// 删除/替换数据库敏感字符
	virtual String RvRpDBCharacter(String &str, bool bRemove = true);
	
	// 生成成就
	virtual void 	addCreatureAllEffort(CharPtr & pChr);
	// 生成Json成就,以Json形式存储成就数据
	virtual void 	BuildCreatureAllEffortByJson(CharPtr &pChr);
	
	// 完成成就
	virtual void CompleteEffort(CharPtr & pChr, Effect * pEffect);
	// 成就加点(Json),达到最大值时会自动完成,返回是否完成
	virtual bool addEffortPointByJson(EffectPtr &pEffLogic, const uint32 &effortId, const uint32 &addNum = 1);	
	// 领取成就奖励(Json,仅做可领取判断和已领取标记,奖励物品增加需自行处理)
	virtual bool GetEffortBonusByJson(EffectPtr &pEffLogic, const uint32 &effortId);
	// 取得物品的名称
	virtual String GetItemName(const uint32 & model_id);
	
	// 合并相同物品数据
	virtual void CombItemData(CharPtr & pChr);
	// 取得最佳登陆服务器
	void SelectLoginServer(UserAuthenticInfo * info);
	void DisposeSceondLogin(UserAuthenticInfo * info);
	// 正常登陆验证函数
	virtual void WorldUserAuthentication(UserAuthenticInfo * info);
	// 处理客户端登陆后数据
	virtual bool DisposeAuthentication(CharPtr & pChr);
	virtual bool DisposeRobotAuthentication(CharPtr & pChr);
	// 平台贵宾用户额外奖励
	virtual bool WebUserLogingBounty(CharPtr & pChr);
	// 救济礼包
	virtual bool NewPlayerSubsidy(CharPtr & pChr, bool isInstant = false);
	
	
	
	// 重置某些数据
	void resetSomeData(CharPtr & pChr);
	
	/**
	 * @创建时间 2015-10-23
	 * @创建人 张楠
	 * @函数作用 创建邮件
	 * @参数
	 * 	@pid 接收方玩家PID
	 *  @szTitle 邮件标题
	 * 	@szContent 邮件内容JSON格式  content节点表示内容，items表示附件，send_user表示发件方名称，sedn_serial表示发件方ID
	 * 	@send_uid 发件方UID（0表示系统）
	 * 	@reson 添加附件的原因（用于日志记录时候记录日志的子来源类型）
	 * 	@mapItems 附件列表
	 */
	virtual bool CreateMail(const uint32 & pid, const String & szTitle, 
							const String & szContent,
							const uint32 & send_uid = 0,
							const uint32 & reson = 0,
							std::map<uint32,uint32> * mapItems = NULL);
	
	// 添加带铜钱的附件
	virtual bool CreateCoinsMail(const uint32 & pid,const String & szTitle,const String & szContent,const uint32 & coins);
	
	// 比赛奖励邮件
	virtual bool CreateBonusMail(UserPtr & pUser,const uint32 & town_id, const uint32 & model_id, const uint32 & num, const uint32 & order);
	// 兑换申请邮件
	virtual bool CreateChangeMail(UserPtr & pUser, const String & szItemName, const String & szOrderfrom);
	// 实物奖励邮件
	virtual bool CreatePracticMail(UserPtr & pUser, const uint32 & town_id, const String & szCode);
	// 增加角色经验
	virtual bool AddCreatureExps(CharPtr & pChr, const uint32 & addnum);
	// 登陆礼包 isInstant:是否立即奖励, 返回连续登陆天数
	uint8 ProvideLoginGift(CharPtr &pChr, bool isInstant = true);
	// 财神卡相关
	ItemPtr AddMammonCard(CharPtr & chr, const uint32 modelId, const uint32 addnum);
	bool ReduceMammonCard(CharPtr & chr, const uint32 rNum, uint32 &coins);
	bool UpdateMammonCard(CharPtr & chr);
	bool BeHadMammonCard(CharPtr & chr);
	// 补财神卡（财神驾到）
	void MammonCome(CharPtr & chr, bool bPresend = false);
	/*** 幸运卡相关 ***/
	void TouchLuckyCard(CharPtr & chr, int32 winCoins);
	void GetLuckCard(CharPtr & chr, ItemPtr & luckCard);
	void GetLuckCardList(CharPtr & chr, std::list<ItemPtr> &lstLucks);
	// 增加幸运卡经验值
	void AddLuckyCardExps(CharPtr & pChr,const uint32 & model_id,uint32 & num);
	
	// 自身和目标玩家共有信息追加包
	void PacketPlayerSameInfo(WorldPacket * pPacket, CharPtr & pChr);
	
	// 获取msg数据(添加语言后缀)
	String GetMsgData(char* key, UserPtr &pUser);
	// 获取msg类型(添加语言后缀)
	uint32 GetMsgType(char* key, UserPtr &pUser);
	
	/****************任务相关**************/
	//创建麻将任务给玩家
	void CreateMaJonMissionsToChar(CharPtr & pChr,std::vector<MaJonMission> * pMissions,const uint8 offset_value);
	//完成麻将任务
	void FinishMaJonMission(CharPtr & pChr,MaJonMission & mission);
	/****************福利勋章**************/
	// 通知领取福利
	virtual bool NoticeWelfare(CharPtr & pChr);
	// 领取福利
	virtual bool GainWelfare(CharPtr & pChr);
	/****************救济卡***************/
	// 救济卡
	bool GainSubsidyCard(CharPtr & pChr);	
	// 领取周卡月卡
	bool GainWeekMonthCard(CharPtr & pChr, const uint8 & type);
	/*****************乐码****************/
	// 生成乐码
	bool CreateLECards(std::list<GameExchange> * cards,const uint32 & pid,const uint32 & cardsNum,const uint32 & cardsType,const uint32 & days = 30);
	// 检测过期乐码
	void CheckTimeOverLeCards(const uint32 & pid);
	/****************乐币积分相关**************/
	//玩家投币
	uint32 PutCoins(CharPtr & pChr,const uint32 & token_num);
	//玩家积分换钱
	uint32 ChangeCoins(CharPtr & pChr,const uint32 & score);
	/****************随机生成昵称**************/
	String GetNickWords(void);
	/**************平台API调用函数**************/
	String getConfigFromUrl(const String & url);
	// 判断字符串是否存在表情字符
	bool containerEmojiCharacter(String strSrc);
	// 判断字符是否表情字符
	bool isEmojiCharacter(char character);
	// 过滤掉表情字符
	String filterEmoji(String source);
	
	/****************弹幕相关*******************/
	bool SendChannelDanMu(CharPtr & pChr,uint32 danmu_serial,uint16 pos,String content);
	bool SendTownDanMu(CharPtr & pChr,uint32 danmu_serial,uint16 pos,String content);
	
	void GetDanMuHistoryList(CharPtr & pChr,const uint8 & type);
	
	/************************JSON格式任务*************************/
	/**
	 * @函数功能 创建任务通过JSON格式来管理所有任务列表
	 * @描述：支持周期性任务更新，以及非周期性任务
	 * @参数 
	 *  @pChr				玩家角色ptr
	 *	@missionModels  	游戏任务模式列表（即要生成到玩家身上的任务）
	 *	@missionstyle  		任务类型（1 每日任务 2 永久任务）
	 */
	bool BuildCommonJsonMission(CharPtr & pChr,std::list<ResourcePtr> missionModels,const uint8 & missionstyle);
	
	/**
	 * @函数功能 任务完成数值增加
	 * @参数 
	 *  @pChr				玩家角色ptr
	 *  @count				完成次数（例如游戏局数，胜利次数等类型任务）
	 */
	bool AddMissionFinishCount(CharPtr & pChr,const uint32 & mission_type,const uint32 & count = 1);
	
	/**
	 * @函数功能 任务是否达到某个完成条件
	 * @参数 
	 *  @pChr				玩家角色ptr
	 *  @value				任务当前达到的数值(例如等级达到，金钱达到类型的任务）
	 */
	bool HasMissionCompalateAtValue(CharPtr & pChr,const uint32 & mission_type,const uint32 & value = 0);
	
	/**
	 * @函数功能 设置任务完成进度（有的任务可能会出现进度减少的情况）
	 * @参数 
	 *  @pChr				玩家角色ptr
	 *  @value				任务当前达到的数值(例如等级达到，金钱达到类型的任务）
	 */
	bool SetMissionCompalateAtValue(CharPtr & pChr,const uint32 & mission_type,const uint32 & value = 0);
	
	/**
	 * @函数功能 领取JSON格式任务奖励
	 * @参数 
	 *  @pChr		玩家角色ptr
	 *  @model_id	领取任务奖励的任务模式ID
	 */
	bool GetJsonMissionBounty(CharPtr & pChr,const uint32 & model_id);
	
	/************************JSON格式任务*************************/
	
	/************************JSON格式成就*************************/
	
	/**
	 * @函数功能 创建任务通过JSON格式来管理所有成就列表
	 * @参数 
	 *  @pChr			玩家角色ptr
	 *  @model_id		JSON成就模式ID
	 *	@effortModels  	游戏成就模式列表（即要生成到玩家身上的成就）
	 */
	bool BuildCommonJsonEffort(CharPtr & pChr, std::list<ResourcePtr> effortModels, const uint32 & effort_modelid = 0);
	bool BuildCommonJsonEffort(CharPtr & pChr, std::vector<stSignleEffortInfo> effortModels, const uint32 & effort_modelid, const uint8 & isSameDate);
	/**
	 * 2018-01-30
	 * @函数功能 重置成就
	 * @参数 
	 *  @pChr	玩家角色ptr
	 */
	bool ReSetCommonJsonEffort(CharPtr & pChr);
	
	/**
	 * @函数功能 成就完成数值增加
	 * @参数 
	 *  @pChr	玩家角色ptr
	 *  @count	完成次数
	 */
	bool AddEffortFinishCount(CharPtr & pChr,const uint32 & mission_type,const uint32 & count = 1);
	bool AddEffortFinishCountByGateway(String strParmars, String & strReturn);
	String SendAddEffortFinishCountFromGateway(Json::Value & val);
	
	/**
	 * @函数功能 成就是否达到某个完成条件
	 * @参数 
	 *  @pChr	玩家角色ptr
	 *  @value	成就当前达到的数值
	 */
	bool HasEffortCompalateAtValue(CharPtr & pChr,const uint32 & mission_type,const uint32 & value = 0);
	bool HasEffortCompalateAtValueByGateway(String strParmars, String & strReturn);
	String SendHasEffortCompalateAtValueFromGateway(Json::Value & val);
	
	/**
	 * @函数功能 设置成就完成进度（适用于有进度减少的情况）
	 * @参数 
	 *  @pChr	玩家角色ptr
	 *  @value	成就当前达到的数值
	 */
	bool SetEffortCompalateAtValue(CharPtr & pChr,const uint32 & mission_type,const uint32 & value = 0);
	bool SetEffortCompalateAtValueByGateway(String strParmars, String & strReturn);
	String SendSetEffortCompalateAtValueFromGateway(Json::Value & val);
	
	/**
	 * @函数功能 领取JSON格式成就奖励
	 * @参数
	 *  @pChr		玩家角色ptr
	 *  @model_id	领取成就奖励的任务模式ID
	 */
	bool GetJsonEffortBounty(CharPtr & pChr,const uint32 & model_id);
	
	/**
	 * @函数功能 JSON格式成就完成数量
	 * @参数
	 *  @pChr		玩家角色ptr
	 */
	uint32 GetJsonEffortComplateNumber(CharPtr & pChr);
	
	/************************JSON格式成就*************************/
	
	/*************************公共排行逻辑*************************/
	/**
	 * @函数功能 生成排行数据
	 */
	void UpdateCommonPlayerQueueTop(bool bForceUpdate = false);
	
	/**
	 * @函数功能 更新排行信息
	 * @参数
	 *  @gzId		分区ID
	 *  @topType	排行类型
	 *  @lstQT		排行列表数据
	 */
	void UpdateCommonPlayerTop(const uint32 gzId, const uint32 topType, std::list<stCommonQueueTop> &lstQT);
	
	/**
	 * @函数功能 获得排行信息
	 * @参数
	 *  @pChr		玩家角色ptr
	 *  @gzId		分区ID
	 *  @topType	排行类型
	 */
	void GetCommonTopQueue(CharPtr & pChr,const uint32 gzId,const uint32 topType);
	void GetCommonTopQueueNew(CharPtr & pChr,const uint32 gzId,const uint32 topType,const uint8 & offset, const uint8 & num);
	// 玩家牌型数据更新
	virtual void UpdateOrderDataToDatabase(CharPtr & pChr){}
	
	/*************************公共排行逻辑*************************/
	
	/*************************公共组局相关*************************/
	ChannelPtr CreateCenterChannel(stPlayerCreateCenterBattle stPCB);
	
	/**
	 * @函数功能 检测同IP玩家
	 * @返回值				true 有同IP玩家，false 没有同IP玩家
	 * @参数
	 *  @vChars				检测的玩家列表
	 *  @mapSameIPChars		返回同IP玩家列表
	 */
	bool CheckHaveSameIpPlayers(std::vector<CharPtr> vChars);
	
	/********************** 棋牌圈测试 ***********************************/
	ChannelPtr CreateCenterChannel();
	
	/*************************每日输赢限额****************************/
	// 增加减少每日输赢
	void AddDayWinLoseLimitCoins(CharPtr & pChr,int winLose);
	void ReduceDayWinLoseLimitCoins(CharPtr & pChr,int winLose);
	
	// 重置每日输赢总额
	void ReSetDayWinLoseLimitCoins(CharPtr & pChr);
	
	// 是否达到输赢限额(0 未达到限额 1 达到赢钱上限  2 达到输钱上线）
	uint8 IsReachDayWinLoseLimitCoins(CharPtr & pChr);
	
	/*************************每日输赢限额****************************/
	
	// 离开服务器前做些事情
	virtual void DoSomethingBeforeExitGameServer(CharPtr & pChr);
	
	// 检测组局牌桌非正常结束（在服务器重启的时候区域接口里面进行检测，让组局状态能被修改未结束）
	void CheckZujuChannelOver();
	
	//=======================赠送道具=================================
	// 送道具
	bool SendItemToUser(CharPtr & pChr, const uint32 & recv_pid, const uint32 & model_id, const uint32 & num);
	// 增加赠收道具日志
	bool UserGiveItemLog(UserPtr &pGiveUser, const uint32 & recv_pid, String recv_name, const uint32 & model_id, const uint32 & num, const uint32 & kucun);
	bool UserRecvItemLog(const uint32 &recv_pid, String &recv_name, UserPtr &pGiveUser, const uint32 & model_id, const uint32 & num);
	//=======================赠送道具=================================
	
	// 网关发送邮件给玩家
	uint8 SendSystemMail(String strParmars);
	// 网关发送邮件给玩家New
	uint8 SendSystemMailNew(String strParmars);
	// 网关给玩家加道具
	uint8 PlayerGiveItemsFromGWToPlayer(String strParmars);
	// 查询物品数量
	uint8 QueryPlayerItemNumber(String strParmars, String & extra_info);
	
	// 获取玩家经纬度
	bool GetUserLongitudeAndLatitude(const uint32 & pid, double & longitude, double & latitude, double & altitude);
	
	// 获得玩家模糊IP地址(xxx.xxx.*)
	String GetCharVagueIp(CharPtr & pChr);
	
	// 购买打包商品
	bool UserBuyUnionGoods(CharPtr & pChr, const uint32 & goods_id, const uint32 & buy_count, std::map<uint32, uint32> * mapGoods);
	
	// 加上字符串斜线
	void ChangeYinHaoToXian(String & strVal);
	// 去掉字符串斜线
	void ChangeXianToYinHao(String & strVal);

	//---------------------------调用网关相关--------------------------------
public:	
	// 添加代理收益（对局费收益）
	bool AddPlayerIncomeInfoToUrl(stIncomeInfo & stInfo);
	// 添加代理收益（赢钱抽水收益）
	bool AddPlayerIncomeInfoToUrlWithPidNum(stIncomeInfo & stInfo);
	
	// 添加代理下注收益
	bool AddPlayerChipinIncomeInfoToUrl(stIncomeInfo & stInfo);
	
	// 获取代理货币数量 192.168.0.119:9090/third/platform/xxjjcGetPoints
	uint32 GetAgentCoinsNum(CharPtr & pChr);
	// 设置代理货币数量 192.168.0.119:9090/third/platform/xxjjcModifyPoints
	void ChangeAgentCoinsNum(CharPtr & pChr, const int32 & num);
	
	// 根据gz_id获取服务器信息
	String GetTargetServerUrlInfo(const uint32 & gz_id, const uint32 & agent_id = 0);
	// 获取某分区服务器http_host地址
	String GetTargetHttpHost(const uint32 & gz_id, const uint32 & agent_id = 0);
	// 获取某分区服务器gameid
	uint32 GetTargetServerGameid(const uint32 & gz_id, const uint32 & agent_id = 0);
	// 发送创建牌桌网关信息到服务器
	bool SendCreateChannelGateway(CharPtr & pChr, String strData, String & strExtraData, String & strShareInfo);
	// 发送创建比赛网关信息到服务器
	uint8 SendCreateGameMatchGateway(CharPtr & pChr, String strData, String & strExtraData, String & strShareInfo);
	// 发送比赛开始信息到服务器
	bool SendGameMatchStartGateway( String strData, String & strExtraData);
	// 发送创建比赛角色到服务器
	bool SendGameMatchCreateCharGateway(String strData, String & strExtraData);
	// 发送比赛开始信息到服务器
	bool SendGameMatchDissolveGateway(String strData, String & strExtraData);

	bool SendSystemCreateChannelGateway(String strData);
	// 发送组局操作网关指令到服务器
	uint8 SendOpCenterBattleGateway(String strData);
	// 处理网关组局操作
	uint8 DealOperateCenterBattleGateway(String strData);
	
	// 发送加钱处理到网关
	uint8 SendAddItemGateway(String strData);
	// 处理网关加钱操作
	uint8 AddItemFromGatewayToPlayer(String strData);
	// 处理网关货币操作
	uint8 OperatorItemFromGatewayToPlayer(String strData);
	// 处理网关查询玩家成就数据
	uint8 QueryPlayerEffortsFromGateway(String strData, String & return_data);
	
	// 从Url获取微信分享内容
	String GetWXShareInfo(CenterBattle & cb, String strPlatform);
	// 测试机器人创建组局
	bool TestRobotCreateChannel();
	// 测试机器人查询组局数据
	bool TestRobotQueryData();
	// 退出服务器
	uint8 ExitGameServer(String strParmars);
	// 发送退出服务器网关
	bool SendExitGameServerGateway(String strData);
	
	// 发送网关充值数据
	uint32 SendUserBuyItems(Json::Value valData);
	// 充值道具
	uint32 UserBuyItems(Json::Value valData, String & return_String);
	
	// 获取房间人数
	uint32 GetRoomPlayerCountByGzid(String strData, String & extra_info);
	// 发送网关请求房间人数
	uint32 SendQueryTownPlayerCountToGateway(String strData);
	
	// 获取玩家道具数量
	uint32 GetItemNumByGzid(String strData, String & extra_info);
	// 发送网关请求道具数量
	uint32 SendQueryItemNumToGateway(String strData);
	
	// 查询在线玩家数量
	bool QueryOnlinePlayerCount(String strData, String & return_info);
	
	// 查询游戏牌桌详情
	String GetGameTableListInfoByGateway(String & strData);
	// 游戏自身牌桌列表数据查询
	virtual bool GetGameTableListSelf(String & strData, String & return_data){ return false; }
	// 发送斗地主牌桌列表
	void SendDDZChannelListInfo(String & strData);
	
	// 网关通知俱乐部牌局超时结束
	uint8 NoticeClubBattleTimesUp(String & strData);
	
	// 向目标服务器玩家发送系统消息
	uint8 SendSystemMessageToTargetServer(const uint32 & pid, String & content, const uint32 & message_type, const uint32 & agent_id = 0);
	uint8 SendSystemMessageFromGateway(String & strData);
	
	// 目标服务器存储数据
	uint8 ChangeCharacterOrderData(String & strData);
	
	// 获取比赛可观战牌桌
	uint32 GetMatchWatchChannelId(String & strData, String & returnData);
	
	// 获取配置的道具物品
	bool GetGatewayGoodsInfo(CharPtr & pChr);
	// 获取兑换奖励配置
	std::vector<stGatewayExChangeInfo> GetExchangeBountyInfo(CharPtr & pChr);
	// 兑换实物
	bool ExchangeRealGoods(CharPtr & pChr, String & strData);
	// 获取玩家联系信息
	bool GetUserContactInfo(CharPtr & pChr);
	// 设置玩家联系信息
	bool SetUserContactInfo(CharPtr & pChr, String & strData);
	
	// 俱乐部管理员给游戏中玩家退分
	uint8 ClubManagerTuifenPlayingPlayer(String strData);
	// 玩家在游戏被管理员退分
	uint8 PlayerClubTuiFenWhenPlayingComplate(String strData);
	
	// 游戏中玩家通知俱乐部退分
	uint8 PlayingPlayerNoticeTuiFen(String strData);
	// 大厅处理玩家退分请求
	uint8 HallDealPlayerClubTuifen(String strData);
	
	// 得到随机头像图标地址
	String GetRandomHeadIcon(const uint32 & agent_id = 0);
	
	// 网关请求充值道具
	uint8 GatewayOpeartorGoods(String & strParmars, String & return_String);

	// 调用网关玩家离线
	/* /platform/usereExit
	METHOD GET
	PARAMS
	ts
	pid
	sig
	RESULT
	true
	false */
	void SendUrlPlayerExitGame(UserPtr & pUser);
	
	//=========================网关成就相关============================
	// 通过网关领取指定服务器的成就奖励
	bool SendGetEffortBountyByGateway(CharPtr & pChr, String strData);
	// 来自网关领取成就奖励
	bool GetEffortBountyFromGateway(String strData, String & return_data);
	// 完成平台游戏局数成就（游戏服务器调用）
	bool ComplateGameLoopPlatformEffort(CharPtr & pChr, const uint32 & extra_data = 0);
	// 完成平台当庄次数成就
	bool ComplateBankerCountPlatformEffort(CharPtr & pChr);
	// 完成平台特殊牌型次数成就
	bool ComplateSpecialCardsPlatformEffort(CharPtr & pChr, const uint32 & card_type);
	
public:
	uint32 m_bByGzid;	//排行是否以分区来进行排
	
	typedef std::list<stCommonQueueTop> CommonTopList;
	std::map<uint32, std::map<uint32, CommonTopList> > m_mapTopQueues;
	
	// 更新char表金钱
	virtual void UpdateAboutMoney(CharPtr &pChr, const uint32 modelId, const uint32 num);
	// 当前正在处理登陆数
	Threading::AtomicCounter m_authen_queue_count;	
	// 当前服务器是否关闭连接
	Threading::AtomicBoolean m_isCloseServer;
	// 昵称列表
	std::vector<String> m_vecNicks;
	// 弹幕记录
	std::map<uint32,std::vector<stDanMu> > m_mapDanMuChannelHistory;
	std::map<uint32,std::vector<stDanMu> > m_mapDanMuTownHistory;
	
	std::map<uint32, String> m_mapTargetGzIdInfo;
	
	// 在游戏服务器中创建的组局列表
	std::vector<uint32> m_vCenterBattleIds;
	
	// 兑换配置列表
	std::map<uint32, std::map<uint32, std::vector<stGatewayExChangeInfo> > > m_mapGatewayExChangeInfo;
	// 排行更新时间
	std::map< uint32, std::map<uint32, uint32> > m_mapOrderUpdateTimer;
	// std::map<uint32, uint32> m_mapOrderUpdateTimer;
	// 排行重置时间
	std::map<uint32, uint32> m_mapOrderResetTimer;
};


//=====================================算术式解析============================
enum enSymbolType
{
	enSymbolType_Int = 1,					//整数
	enSymbolType_Float = 2,					//浮点
	enSymbolType_Addition = 3,				//加法
	enSymbolType_Subtraction = 4,			//减法
	enSymbolType_Multiplication = 5,		//乘法
	enSymbolType_Division = 6,				//除法
	enSymbolType_Power = 7,					//乘方
	enSymbolType_ExtractRoot = 8,			//开方
	enSymbolType_LeftParenthesis = 9,		//左括号
	enSymbolType_RightParenthesis = 10,		//→括号
	enSymbolType_Remainder = 11,			//取余


	enSymbolOperatorType_unary = 1,				//单目运算符
	enSymbolOperatorType_binary = 2,			//双目运算符
};

#define MAX_FINCE 9




struct Symbol
{
	static const String SymbolList[MAX_FINCE];
	static const int SymbolOperatorTypeList[MAX_FINCE];
	static const int SymbolOperatorRankList[MAX_FINCE];
	void * value;
	int type;
	int pos;
	void setPos(int _pos);
	Symbol(const Symbol & val);
	Symbol();
	Symbol(int val, int _pos);
	Symbol(float val, int _pos);
	Symbol(String val, int _pos);
	Symbol& operator=(int val);
	Symbol& operator=(float val);
	/*Symbol& operator=(Symbol & val);*/
	void operator=(const Symbol & val);
	int GetSymbolOperatorType();
	int GetSymbolOperatorRank();
	bool isNumber();
	int asInt();
	float asFloat();
	~Symbol();
};
Symbol Addition(Symbol a, Symbol b);
Symbol Subtraction(Symbol a, Symbol b);
Symbol Multiplication(Symbol a, Symbol b);
Symbol Division(Symbol a, Symbol b);
Symbol Power(Symbol a, Symbol b);
Symbol Remainder(Symbol a, Symbol b);

Symbol ExtractRoot(Symbol a);

typedef Symbol(*SymbolFunc_unary)(Symbol);
typedef Symbol(*SymbolFunc_binary)(Symbol, Symbol);

class ArithmeticReader
{
	static std::map<int, SymbolFunc_unary> unaryFunc;
	static std::map<int, SymbolFunc_binary> binaryFunc;
public:
	std::vector<Symbol> m_vecSymbolList;

	bool read(String val);
	bool read(const char * query, ...);

	std::vector<Symbol> analyse(String val);
	std::map<int, int> GetParentheseOrder(std::vector<Symbol> vecSymbolList);
	Symbol RunArithmetic(std::vector<Symbol> vecSymbol);
protected:

	String ArithmeticString;
};


#endif
